M

MLOG

ไทย

ปลดล็อกพลังแห่งการประมวลผลแบบไร้เซิร์ฟเวอร์ด้วย Google Cloud Functions คู่มือนี้จะสำรวจ HTTP triggers เพื่อให้ความรู้แก่นักพัฒนาทั่วโลกในการสร้างแอปพลิเคชันที่ปรับขนาดได้และขับเคลื่อนด้วยเหตุการณ์

Google Cloud Functions: คู่มือฉบับสมบูรณ์สำหรับ HTTP Triggers

Google Cloud Functions (GCF) เป็นสภาพแวดล้อมการประมวลผลแบบไร้เซิร์ฟเวอร์ที่ช่วยให้คุณสร้างและเชื่อมต่อบริการคลาวด์ ด้วย Cloud Functions คุณเขียนฟังก์ชันง่ายๆ ที่มีวัตถุประสงค์เดียวซึ่งเชื่อมโยงกับเหตุการณ์ที่ปล่อยออกมาจากโครงสร้างพื้นฐานและบริการคลาวด์ของคุณ ฟังก์ชันของคุณจะถูกเรียกใช้เมื่อเกิดเหตุการณ์ที่คุณกำลังเฝ้าดู วิธีการนี้ช่วยให้คุณพัฒนาแอปพลิเคชันที่ขับเคลื่อนด้วยเหตุการณ์ได้โดยไม่ต้องจัดการเซิร์ฟเวอร์หรือรันไทม์

หนึ่งในวิธีที่พบบ่อยที่สุดในการเรียกใช้ Cloud Function คือผ่าน HTTP request คู่มือนี้จะเจาะลึกโลกของ HTTP triggers ใน Google Cloud Functions เพื่อให้คุณมีความรู้ในการสร้างแอปพลิเคชันที่ทรงพลัง ปรับขนาดได้ และคุ้มค่า

HTTP Triggers คืออะไร?

HTTP trigger ช่วยให้คุณเรียกใช้ Cloud Function ของคุณเพื่อตอบสนองต่อ HTTP request โดยพื้นฐานแล้ว เมื่อมีการส่ง HTTP request ไปยัง URL เฉพาะ Google Cloud Functions จะเรียกใช้ฟังก์ชันที่เกี่ยวข้องโดยอัตโนมัติ สิ่งนี้ทำให้ HTTP triggers เหมาะอย่างยิ่งสำหรับการสร้าง APIs, webhooks และเว็บแอปพลิเคชันที่ขับเคลื่อนด้วยเหตุการณ์

ประโยชน์หลักของการใช้ HTTP Triggers:

การสร้าง Cloud Function ด้วย HTTP Trigger

เราจะมาดูขั้นตอนการสร้าง Cloud Function ง่ายๆ ด้วย HTTP trigger เราจะสร้างฟังก์ชันที่ตอบกลับด้วยข้อความ "Hello, World!" ตัวอย่างนี้สามารถปรับเปลี่ยนได้สำหรับภาษาท้องถิ่นทั่วโลกต่างๆ โดยการแก้ไขสตริงผลลัพธ์

สิ่งที่ต้องมี:

ขั้นตอน:

  1. สร้างโปรเจกต์ใหม่ (หากคุณยังไม่มี):

    หากคุณยังไม่มี GCP project โปรดสร้างใน Google Cloud Console

  2. เปิดใช้งาน Cloud Functions API:

    ใน Cloud Console ไปที่ Cloud Functions API และเปิดใช้งาน

  3. สร้างไดเร็กทอรีสำหรับฟังก์ชัน:

    สร้างไดเร็กทอรีใหม่สำหรับ Cloud Function ของคุณ ตัวอย่างเช่น:

    mkdir hello-http
cd hello-http
  4. เขียนโค้ดฟังก์ชัน:

    สร้างไฟล์ชื่อ `main.py` (หรือ `index.js` สำหรับ Node.js) ด้วยโค้ดต่อไปนี้:

    Python (main.py):

    def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
        
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `make_response`
        `.
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and 'name' in request_json:
        name = request_json['name']
    elif request_args and 'name' in request_args:
        name = request_args['name']
    else:
        name = 'World'
    return f'Hello, {name}!'

    Node.js (index.js):

    exports.helloHttp = (req, res) => {
  let name = 'World';
  if (req.body.name) {
    name = req.body.name;
  } else if (req.query.name) {
    name = req.query.name;
  }
  res.status(200).send(`Hello, ${name}!`);
};
  5. สร้างไฟล์ Requirements (เฉพาะ Python):

    หากคุณใช้ Python ให้สร้างไฟล์ชื่อ `requirements.txt` และเพิ่ม dependencies ที่ฟังก์ชันของคุณต้องการ สำหรับตัวอย่างนี้ สิ่งนี้ไม่จำเป็นอย่างยิ่ง แต่ก็เป็นแนวทางปฏิบัติที่ดีในการรวมไว้ คุณสามารถปล่อยให้ว่างได้หากคุณไม่มี dependencies

  6. ปรับใช้ฟังก์ชัน:

    ใช้คำสั่ง `gcloud functions deploy` เพื่อปรับใช้ฟังก์ชันของคุณ แทนที่ `YOUR_FUNCTION_NAME` ด้วยชื่อที่ต้องการสำหรับฟังก์ชันของคุณ

    Python:

    gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime python39 \
    --trigger-http \
    --allow-unauthenticated

    Node.js:

    gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime nodejs16 \
    --trigger-http \
    --allow-unauthenticated

    คำอธิบายพารามิเตอร์:

    • `YOUR_FUNCTION_NAME`: ชื่อที่คุณต้องการตั้งให้กับ Cloud Function ของคุณ
    • `--runtime`: สภาพแวดล้อมรันไทม์สำหรับฟังก์ชันของคุณ (เช่น `python39`, `nodejs16`)
    • `--trigger-http`: ระบุว่าฟังก์ชันควรถูกเรียกใช้โดย HTTP requests
    • `--allow-unauthenticated`: อนุญาตให้ใครก็ตามเรียกใช้ฟังก์ชันได้โดยไม่ต้องมีการยืนยันตัวตน คำเตือน: ใช้ความระมัดระวังเมื่อเปิดใช้งานสิ่งนี้ในสภาพแวดล้อมการผลิต! พิจารณาการใช้การยืนยันตัวตนและการอนุญาตที่เหมาะสม
  7. ทดสอบฟังก์ชัน:

    หลังจากการปรับใช้ คำสั่ง `gcloud` จะแสดง URL ของฟังก์ชันของคุณ จากนั้นคุณสามารถทดสอบได้โดยการส่ง HTTP request ไปยัง URL นั้นโดยใช้เครื่องมือเช่น `curl` หรือ Postman

    curl YOUR_FUNCTION_URL

    คุณควรเห็นข้อความ "Hello, World!" ในการตอบกลับ คุณยังสามารถส่งชื่อเป็นพารามิเตอร์ query ได้:

    curl "YOUR_FUNCTION_URL?name=YourName"

    สิ่งนี้ควรตอบกลับ "Hello, YourName!"

การทำความเข้าใจ HTTP Request และ Response

เมื่อ Cloud Function ถูกเรียกใช้โดย HTTP request ฟังก์ชันจะได้รับ object ที่มีข้อมูลเกี่ยวกับ request โดยทั่วไป object นี้จะรวมถึง:

ฟังก์ชันของคุณควรส่งคืน HTTP response ซึ่งรวมถึง:

ตัวอย่าง: การจัดการ HTTP Methods ที่แตกต่างกัน

นี่คือตัวอย่างวิธีการจัดการ HTTP methods ที่แตกต่างกันใน Cloud Function ของคุณ:

Python (main.py):

from flask import escape

def http_method(request):
    """Responds to any HTTP request.
    Args:
        request (flask.Request): HTTP request object.
    Returns:
        The response text or any set of values that can be turned into a
        Response object using
        `make_response``.
    """
    if request.method == 'GET':
        return 'This is a GET request!'
    elif request.method == 'POST':
        request_json = request.get_json(silent=True)
        if request_json and 'message' in request_json:
            message = escape(request_json['message'])
            return f'This is a POST request with message: {message}'
        else:
            return 'This is a POST request without a message.'
    else:
        return 'Unsupported HTTP method.', 405

Node.js (index.js):

exports.httpMethod = (req, res) => {
  switch (req.method) {
    case 'GET':
      res.status(200).send('This is a GET request!');
      break;
    case 'POST':
      if (req.body.message) {
        const message = req.body.message;
        res.status(200).send(`This is a POST request with message: ${message}`);
      } else {
        res.status(200).send('This is a POST request without a message.');
      }
      break;
    default:
      res.status(405).send('Unsupported HTTP method!');
      break;
  }
};

อย่าลืมปรับใช้ฟังก์ชันที่อัปเดตโดยใช้คำสั่ง `gcloud functions deploy`

การรักษาความปลอดภัย HTTP Triggers ของคุณ

ความปลอดภัยเป็นสิ่งสำคัญสูงสุดเมื่อทำงานกับ HTTP triggers โดยเฉพาะอย่างยิ่งเมื่อเกี่ยวข้องกับข้อมูลที่ละเอียดอ่อนหรือการดำเนินงานที่สำคัญ นี่คือข้อควรพิจารณาด้านความปลอดภัยที่สำคัญ:

การยืนยันตัวตนและการอนุญาต

โดยค่าเริ่มต้น Cloud Functions ที่ถูกเรียกใช้โดย HTTP สามารถเข้าถึงได้แบบสาธารณะหากคุณใช้ `--allow-unauthenticated` ในสถานการณ์การผลิตส่วนใหญ่ คุณจะต้องจำกัดการเข้าถึงเฉพาะผู้ใช้หรือบริการที่ได้รับอนุญาต Google Cloud มีตัวเลือกมากมายสำหรับการยืนยันตัวตนและการอนุญาต:

การตรวจสอบความถูกต้องของข้อมูลขาเข้า

ตรวจสอบข้อมูลขาเข้าที่ได้รับจาก Cloud Function ของคุณเสมอ เพื่อป้องกันช่องโหว่ด้านความปลอดภัย เช่น SQL injection หรือ cross-site scripting (XSS) ใช้เทคนิคการทำให้บริสุทธิ์และหลีกเลี่ยงที่เหมาะสมเพื่อป้องกันข้อมูลขาเข้าที่เป็นอันตราย

HTTPS

ตรวจสอบให้แน่ใจว่า Cloud Function ของคุณสามารถเข้าถึงได้ผ่าน HTTPS เท่านั้น เพื่อเข้ารหัสการสื่อสารระหว่างไคลเอ็นต์และฟังก์ชัน Google Cloud Functions ให้ endpoints HTTPS โดยอัตโนมัติ

การจำกัดอัตรา

ใช้การจำกัดอัตราเพื่อป้องกันการใช้งานในทางที่ผิดและการโจมตีแบบ denial-of-service (DoS) คุณสามารถใช้บริการเช่น Google Cloud Armor เพื่อปกป้อง Cloud Functions ของคุณจากการรับส่งข้อมูลที่มากเกินไป

กรณีการใช้งานสำหรับ HTTP Triggers

HTTP triggers มีความหลากหลายและสามารถใช้ได้ในหลากหลายแอปพลิเคชัน นี่คือกรณีการใช้งานทั่วไป:

ตัวอย่างในอุตสาหกรรมต่างๆ

เทคนิคขั้นสูง

การใช้ Environment Variables

Environment variables ช่วยให้คุณกำหนดค่า Cloud Function ของคุณได้โดยไม่ต้อง hardcode ข้อมูลที่ละเอียดอ่อนหรือค่าการกำหนดค่าในโค้ดของคุณ คุณสามารถตั้งค่า environment variables โดยใช้คำสั่ง `gcloud functions deploy` หรือใน Google Cloud Console

gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime python39 \
    --trigger-http \
    --set-env-vars API_KEY=YOUR_API_KEY,DATABASE_URL=YOUR_DATABASE_URL

ในโค้ดของคุณ คุณสามารถเข้าถึง environment variables โดยใช้ dictionary `os.environ` (Python) หรือ object `process.env` (Node.js)

Python:

import os

def your_function(request):
    api_key = os.environ.get('API_KEY')
    # Use the API key in your function
    return f'API Key: {api_key}'

Node.js:

exports.yourFunction = (req, res) => {
  const apiKey = process.env.API_KEY;
  // Use the API key in your function
  res.status(200).send(`API Key: ${apiKey}`);
};

การจัดการงานแบบอะซิงโครนัส

สำหรับงานที่ใช้เวลานานหรืองานที่ต้องใช้การคำนวณมาก ควรใช้การประมวลผลแบบอะซิงโครนัสเพื่อหลีกเลี่ยงการบล็อก HTTP request คุณสามารถใช้บริการเช่น Google Cloud Tasks หรือ Cloud Pub/Sub เพื่อถ่ายโอนงานเหล่านี้ไปยังคิวแยกต่างหาก

การจัดการข้อผิดพลาดและการบันทึก

ใช้การจัดการข้อผิดพลาดและการบันทึกที่มีประสิทธิภาพใน Cloud Functions ของคุณเพื่อระบุและแก้ไขปัญหาได้อย่างรวดเร็ว ใช้ Google Cloud Logging เพื่อรวบรวมบันทึกจากฟังก์ชันของคุณและตรวจสอบประสิทธิภาพของฟังก์ชัน

แนวทางปฏิบัติที่ดีที่สุด

การแก้ไขปัญหาทั่วไป

สรุป

Google Cloud Functions พร้อม HTTP triggers มอบวิธีที่ทรงพลังและยืดหยุ่นในการสร้างแอปพลิเคชันแบบไร้เซิร์ฟเวอร์ ด้วยการทำความเข้าใจแนวคิดและเทคนิคที่กล่าวถึงในคู่มือนี้ คุณสามารถใช้ประโยชน์จากพลังของ Cloud Functions เพื่อสร้างโซลูชันที่ปรับขนาดได้ คุ้มค่า และขับเคลื่อนด้วยเหตุการณ์สำหรับผู้ชมทั่วโลก โอบรับการปฏิวัติไร้เซิร์ฟเวอร์และปลดล็อกศักยภาพสูงสุดของแอปพลิเคชันคลาวด์ของคุณ!